home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Small Islands / Small Islands Medium.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  51.3 KB  |  1,577 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Small Island Medium.rmv
  4. //
  5. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  6. // PROPRIETARY and CONFIDENTIAL.
  7. //
  8. // $Author: Scott Marison $
  9. // $Date: 8/06/01 6:57p $
  10. // $Revision: 26 $
  11. // $Revision: 26 $ 
  12. //   Adjusted number of neutrals and percent land
  13. // $Revision: 26 $Revision: 8 
  14. //   Adjusted Angle between team members
  15. // $Revision:
  16. //   Increased # of islands and amount of forest
  17. //  Revision: 10 tweaked land percent
  18. //  Revision: 11 Pushed players and outer neutrals toward the map edge 
  19. //  Revision: 12 Added hills
  20. //  Revision: 13 Lowered hills
  21. //  Revision: 15 Miniaturized
  22. //  Revision: 16 Elevation 
  23. //  Revision: 17 Revised # of resources 3 by 3
  24. //  Revision: 18 8+ player adjustment and enhanced resource placement. 
  25. //  Revision: 19 General Enhancements
  26. //  Revision: 23 Reduced Resources
  27. //  Revision: 26 Evened-out resource distribution 
  28. //  Revision: 26e Small Islands from Large Islands 
  29. //  Revision: 26f Added 1 island 
  30. //
  31. //////////////////////////////////////////////////////////////////////
  32.  
  33. #if            NOTDEFINED(SMALL_ISLANDS_TINY_RMV)
  34. #define        (SMALL_ISLANDS_TINY_RMV,1)
  35.  
  36. //////////////////////////////////////////////////////////////////////
  37. // Definitions we are required to define for small island maps
  38. //////////////////////////////////////////////////////////////////////
  39.  
  40. ResourcePlacementLimit (Gold,     6,    23)
  41. ResourcePlacementLimit (Steel,     6,     23)
  42. ResourcePlacementLimit (Stone,     6,     23)
  43. ResourcePlacementLimit (Berry,     3,     7)
  44. ResourcePlacementLimit (Fish,     1,    40)
  45. ResourcePlacementLimit (Tree,     4,     10)
  46. ResourcePlacementLimit (Animal,     7,     25)
  47.  
  48. #if Is2Players
  49. //////////////////////////////////////////////////////////////////////
  50. // 2 PLAYERS...
  51. //////////////////////////////////////////////////////////////////////
  52.  
  53. //////////////////////////////////////////////////////////////////////
  54. // terrain definitions
  55. #define        (kMinIntElevation,                -10)
  56. #define        (kMaxIntElevation,                8)
  57. #define        (kElevationScale,                    1)
  58. #define        (kPercentLand,                    Between(0.35, 0.35))
  59. #define        (kWaterBorder,                    0)
  60. #define        (kRiverWidth,                    9)
  61. #define        (kCoastToDeepWaterPercentage                1.0)
  62. #define        (kHeightMapChaos,                    Between(8, 12))
  63.         
  64. #define        (kMinimumStartPositionToMapEdge        2)
  65. #define        (kOuterPushFromMapCenter            30)
  66. #define        (kInnerPushFromMapCenter             0)                                
  67.  
  68. //////////////////////////////////////////////////////////////////////
  69. // player definitions
  70. #define        (kMaxAngleBetweenTeamMembers,                40.0)
  71. #define        (kPlayerInnerRadius,                0.6)
  72. #define        (kPlayerOuterRadius,                0.95)
  73. #define        (kPlayerOptimalFactor,                Between(0.5, 0.8))
  74. #define        (kPlayerPercentFlat,                Between(0.8, 0.8))
  75. #define        (kPlayerLandChaos,                0.65)
  76. #define        (kPlayerLandClumps,                1)
  77. #define        (kPlayerFlatChaos,                0.8)
  78. #define        (kPlayerFlatClumps,                1)
  79. #define        (kPlayerTreePercentage,                0.1)
  80.  
  81.  
  82. //////////////////////////////////////////////////////////////////////
  83. // inner neutral definitions
  84. #define        (kNeutralInnerRadius,                0.05)
  85. #define        (kNeutralOuterRadius,                0.05)
  86. #define        (kNeutralOptimalFactor,                0.7)
  87. #define        (kNumInnerNeutrals,                Between(1, 1))
  88. #define        (kInnerNeutralPercentLand,            0.2)
  89. #define        (kInnerNeutralPercentFlat,            Between(.7, .7))
  90. #define        (kInnerNeutralTreePercentage,                0.1)
  91. #define        (kInnerNeutralLandChaos,            0.8)
  92. #define        (kInnerNeutralLandClumps,            Between(1, 1))
  93. #define        (kInnerNeutralFlatChaos,            0.8)
  94. #define        (kInnerNeutralFlatClumps,            1)
  95.  
  96.  
  97. //////////////////////////////////////////////////////////////////////
  98. // outer neutral definitions
  99. #define        (kNumOuterNeutrals,                Between(2, 2))
  100. #define        (kOuterNeutralPercentLand,            0.4)
  101. #define        (kOuterNeutralPercentFlat,            Between(.5, .8))
  102. #define        (kOuterNeutralTreePercentage,                0.1)
  103. #define        (kOuterNeutralLandChaos,            0.8)
  104. #define        (kOuterNeutralLandClumps,            1)
  105. #define        (kOuterNeutralFlatChaos,            0.8)
  106. #define        (kOuterNeutralFlatClumps,            1)
  107.  
  108.  
  109. //////////////////////////////////////////////////////////////////////
  110. // resource definitions
  111. #define        (kMaxResourceElevation,                2)
  112. #define        (kResourceToEdgeDistance,            1)
  113. #define        (kResourceToWaterDistance,            2)
  114.  
  115. #define        (kAnimalPerPlayer,                0)
  116. #define        (kAnimalPerNeutral,                0)
  117.  
  118. #if (IsPaleoEpoch) 
  119.   #define  (kBerryPerPlayer,    2)
  120. #else
  121.   #define  (kBerryPerPlayer,    1)
  122. #endif 
  123. #define        (kBerryPerNeutral,            0)
  124.  
  125. #define        (kFishPerPlayer,                    23)
  126. #define        (kFishPerNeutral,                    0)
  127.                                                 
  128. #define        (kGoldPerPlayer,                    2)
  129. #define        (kGoldPerNeutral,                    3)
  130.  
  131. #define        (kOilPerPlayer,                    0)
  132. #define        (kOilPerNeutral,                    0)
  133.                                                 
  134. #define        (kSteelPerPlayer,                    2)
  135. #define        (kSteelPerNeutral,                3)        
  136.                                                 
  137. #define        (kStonePerPlayer,                    1)
  138. #define        (kStonePerNeutral,                2)        
  139.                                             
  140. #define        (kTreePerPlayer,                    1)
  141. #define        (kTreePerNeutral,                    0)
  142.  
  143.  
  144. //////////////////////////////////////////////////////////////////////
  145. // forest definitions
  146. #define        (kForestFreeRadius,                7.0)
  147. #define        (kForestsPerPlayer,                3)
  148. #define        (kForestChaosLevel,                0.1)
  149. #define        (kMaxClumpsPerForest,                3)
  150.  
  151.  
  152. #elif Is3Players
  153. //////////////////////////////////////////////////////////////////////
  154. // 3 PLAYERS...
  155. //////////////////////////////////////////////////////////////////////
  156.  
  157. //////////////////////////////////////////////////////////////////////
  158. // terrain definitions
  159. #define        (kMinIntElevation,                -10)
  160. #define        (kMaxIntElevation,                8)
  161. #define        (kElevationScale,                      1)
  162. #define        (kPercentLand,                    Between(0.35, 0.35))
  163. #define        (kWaterBorder,                    0)
  164. #define        (kRiverWidth,                    10)
  165. #define        (kCoastToDeepWaterPercentage                1.0)
  166. #define        (kHeightMapChaos,                    Between(8, 12))
  167.         
  168. #define        (kMinimumStartPositionToMapEdge        1)
  169. #define        (kOuterPushFromMapCenter            30)
  170. #define        (kInnerPushFromMapCenter             0)
  171.  
  172. //////////////////////////////////////////////////////////////////////
  173. // player definitions
  174. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  175. #define        (kPlayerInnerRadius,            0.7)
  176. #define        (kPlayerOuterRadius,            0.9)
  177. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  178. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  179. #define        (kPlayerLandChaos,            0.8)
  180. #define        (kPlayerLandClumps,            1)
  181. #define        (kPlayerFlatChaos,            0.8)
  182. #define        (kPlayerFlatClumps,            1)
  183. #define        (kPlayerTreePercentage,            0.1)
  184.  
  185.  
  186. //////////////////////////////////////////////////////////////////////
  187. // inner neutral definitions
  188. #define        (kNeutralInnerRadius,            0.05)
  189. #define        (kNeutralOuterRadius,            0.45)
  190. #define        (kNeutralOptimalFactor,            0.7)
  191. #define        (kNumInnerNeutrals,            Between(2, 2))
  192. #define        (kInnerNeutralPercentLand,        0.4)
  193. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  194. #define        (kInnerNeutralTreePercentage,          0.1)
  195. #define        (kInnerNeutralLandChaos,        0.8)
  196. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  197. #define        (kInnerNeutralFlatChaos,        0.8)
  198. #define        (kInnerNeutralFlatClumps,        1)
  199.  
  200.  
  201. //////////////////////////////////////////////////////////////////////
  202. // outer neutral definitions
  203. #define        (kNumOuterNeutrals,            Between(0, 0))
  204. #define        (kOuterNeutralPercentLand,        0.33)
  205. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  206. #define        (kOuterNeutralTreePercentage,          0.1)
  207. #define        (kOuterNeutralLandChaos,        0.8)
  208. #define        (kOuterNeutralLandClumps,        1)
  209. #define        (kOuterNeutralFlatChaos,        0.8)
  210. #define        (kOuterNeutralFlatClumps,        1)
  211.  
  212.  
  213. //////////////////////////////////////////////////////////////////////
  214. // resource definitions
  215. #define        (kMaxResourceElevation,            2)
  216. #define        (kResourceToEdgeDistance,        1)
  217. #define        (kResourceToWaterDistance,        2)
  218.  
  219. #define        (kAnimalPerPlayer,            0)
  220. #define        (kAnimalPerNeutral,            0)
  221.  
  222. #if (IsPaleoEpoch) 
  223.   #define  (kBerryPerPlayer,    2)
  224. #else
  225.   #define  (kBerryPerPlayer,    1)
  226. #endif 
  227. #define        (kBerryPerNeutral,            0)
  228.  
  229. #define        (kFishPerPlayer,                18)
  230. #define        (kFishPerNeutral,                0)
  231.  
  232. #define        (kGoldPerPlayer,                2)
  233. #define        (kGoldPerNeutral,                4)
  234.  
  235. #define        (kOilPerPlayer,                0)
  236. #define        (kOilPerNeutral,                0)
  237.  
  238. #define        (kSteelPerPlayer,                2)
  239. #define        (kSteelPerNeutral,            4)
  240.  
  241. #define        (kStonePerPlayer,                1)
  242. #define        (kStonePerNeutral,            1)
  243.  
  244. #define        (kTreePerPlayer,                1)
  245. #define        (kTreePerNeutral,                0)
  246.  
  247.  
  248. //////////////////////////////////////////////////////////////////////
  249. // forest definitions
  250. #define        (kForestFreeRadius,            6.0)
  251. #define        (kForestsPerPlayer,            2)
  252. #define        (kForestChaosLevel,            0.1)
  253. #define        (kMaxClumpsPerForest,            2)
  254.  
  255.  
  256. #elif Is4Players
  257. //////////////////////////////////////////////////////////////////////
  258. // 4 PLAYERS...
  259. //////////////////////////////////////////////////////////////////////
  260.  
  261. //////////////////////////////////////////////////////////////////////
  262. // terrain definitions
  263. #define        (kMinIntElevation,                -10)
  264. #define        (kMaxIntElevation,                8)
  265. #define        (kElevationScale,                      1)
  266. #define        (kPercentLand,                    Between(0.35, 0.35))
  267. #define        (kWaterBorder,                    0)
  268. #define        (kRiverWidth,                    10)
  269. #define        (kCoastToDeepWaterPercentage                1.0)
  270. #define        (kHeightMapChaos,                    Between(8, 12))
  271.         
  272. #define        (kMinimumStartPositionToMapEdge        2)
  273. #define        (kOuterPushFromMapCenter            30)
  274. #define        (kInnerPushFromMapCenter             0)                                    
  275. //////////////////////////////////////////////////////////////////////
  276. // player definitions
  277. #define        (kMaxAngleBetweenTeamMembers,          70.0)
  278. #define        (kPlayerInnerRadius,            0.7)
  279. #define        (kPlayerOuterRadius,            0.9)
  280. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  281. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  282. #define        (kPlayerLandChaos,            0.8)
  283. #define        (kPlayerLandClumps,            1)
  284. #define        (kPlayerFlatChaos,            0.8)
  285. #define        (kPlayerFlatClumps,            1)
  286. #define        (kPlayerTreePercentage,            0.1)
  287.  
  288.  
  289. //////////////////////////////////////////////////////////////////////
  290. // inner neutral definitions
  291. #define        (kNeutralInnerRadius,            0.05)
  292. #define        (kNeutralOuterRadius,            0.05)
  293. #define        (kNeutralOptimalFactor,            0.7)
  294. #define        (kNumInnerNeutrals,            Between(1, 1))
  295. #define        (kInnerNeutralPercentLand,        0.27)
  296. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  297. #define        (kInnerNeutralTreePercentage,          0.1)
  298. #define        (kInnerNeutralLandChaos,        0.8)
  299. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  300. #define        (kInnerNeutralFlatChaos,        0.8)
  301. #define        (kInnerNeutralFlatClumps,        1)
  302.  
  303.  
  304. //////////////////////////////////////////////////////////////////////
  305. // outer neutral definitions
  306. #define        (kNumOuterNeutrals,            Between(0, 0))
  307. #define        (kOuterNeutralPercentLand,        0.22)
  308. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  309. #define        (kOuterNeutralTreePercentage,          0.1)
  310. #define        (kOuterNeutralLandChaos,        0.8)
  311. #define        (kOuterNeutralLandClumps,        1)
  312. #define        (kOuterNeutralFlatChaos,        0.8)
  313. #define        (kOuterNeutralFlatClumps,        1)
  314.  
  315.  
  316. //////////////////////////////////////////////////////////////////////
  317. // resource definitions
  318. #define        (kMaxResourceElevation,            2)
  319. #define        (kResourceToEdgeDistance,        1)
  320. #define        (kResourceToWaterDistance,        2)
  321.  
  322. #define        (kAnimalPerPlayer,            0)
  323. #define        (kAnimalPerNeutral,            0)
  324.  
  325. #if (IsPaleoEpoch) 
  326.   #define  (kBerryPerPlayer,    2)
  327. #else
  328.   #define  (kBerryPerPlayer,    1)
  329. #endif 
  330. #define        (kBerryPerNeutral,            0)
  331.  
  332. #define        (kFishPerPlayer,                16)
  333. #define        (kFishPerNeutral,                0)
  334.  
  335. #define        (kGoldPerPlayer,                2)
  336. #define        (kGoldPerNeutral,                3)
  337.  
  338. #define        (kOilPerPlayer,                0)
  339. #define        (kOilPerNeutral,                0)
  340.  
  341. #define        (kSteelPerPlayer,                2)
  342. #define        (kSteelPerNeutral,            3)
  343.  
  344. #define        (kStonePerPlayer,                1)
  345. #define        (kStonePerNeutral,            1)
  346.  
  347. #define        (kTreePerPlayer,                1)
  348. #define        (kTreePerNeutral,                0)
  349.  
  350.  
  351. //////////////////////////////////////////////////////////////////////
  352. // forest definitions
  353. #define        (kForestFreeRadius,            6.0)
  354. #define        (kForestsPerPlayer,            2)
  355. #define        (kForestChaosLevel,            0.1)
  356. #define        (kMaxClumpsPerForest,            2)
  357.  
  358.  
  359. #elif Is5Players
  360. //////////////////////////////////////////////////////////////////////
  361. // 5 PLAYERS...
  362. //////////////////////////////////////////////////////////////////////
  363.  
  364. //////////////////////////////////////////////////////////////////////
  365. // terrain definitions
  366. #define        (kMinIntElevation,                -10)
  367. #define        (kMaxIntElevation,                8)
  368. #define        (kElevationScale,                      1)
  369. #define        (kPercentLand,                    Between(0.45, 0.45))
  370. #define        (kWaterBorder,                    0)
  371. #define        (kRiverWidth,                    10)
  372. #define        (kCoastToDeepWaterPercentage                1.0)
  373. #define        (kHeightMapChaos,                    Between(8, 12))
  374.         
  375. #define        (kMinimumStartPositionToMapEdge        2)
  376. #define        (kOuterPushFromMapCenter            30)
  377. #define        (kInnerPushFromMapCenter             0)
  378.  
  379. //////////////////////////////////////////////////////////////////////
  380. // player definitions
  381. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  382. #define        (kPlayerInnerRadius,            0.7)
  383. #define        (kPlayerOuterRadius,            0.90)
  384. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  385. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  386. #define        (kPlayerLandChaos,            0.8)
  387. #define        (kPlayerLandClumps,            1)
  388. #define        (kPlayerFlatChaos,            0.8)
  389. #define        (kPlayerFlatClumps,            1)
  390. #define        (kPlayerTreePercentage,            0.1)
  391.  
  392.  
  393. //////////////////////////////////////////////////////////////////////
  394. // inner neutral definitions
  395. #define        (kNeutralInnerRadius,            0.05)
  396. #define        (kNeutralOuterRadius,            0.05)
  397. #define        (kNeutralOptimalFactor,            0.7)
  398. #define        (kNumInnerNeutrals,            Between(1, 1))
  399. #define        (kInnerNeutralPercentLand,        0.17)
  400. #define        (kInnerNeutralPercentFlat,        Between(.7, .7))
  401. #define        (kInnerNeutralTreePercentage,     0.1)
  402. #define        (kInnerNeutralLandChaos,        0.8)
  403. #define        (kInnerNeutralLandClumps,        1)
  404. #define        (kInnerNeutralFlatChaos,        0.8)
  405. #define        (kInnerNeutralFlatClumps,        1)
  406.  
  407.  
  408. //////////////////////////////////////////////////////////////////////
  409. // outer neutral definitions
  410. #define        (kNumOuterNeutrals,            Between(0, 0))
  411. #define        (kOuterNeutralPercentLand,        0.11)
  412. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  413. #define        (kOuterNeutralTreePercentage,          0.1)
  414. #define        (kOuterNeutralLandChaos,        0.8)
  415. #define        (kOuterNeutralLandClumps,        1)
  416. #define        (kOuterNeutralFlatChaos,        0.8)
  417. #define        (kOuterNeutralFlatClumps,        1)
  418.  
  419.  
  420. //////////////////////////////////////////////////////////////////////
  421. // resource definitions
  422. #define        (kMaxResourceElevation,            2)
  423. #define        (kResourceToEdgeDistance,        1)
  424. #define        (kResourceToWaterDistance,        2)
  425.  
  426. #define        (kAnimalPerPlayer,            0)
  427. #define        (kAnimalPerNeutral,            0)
  428.  
  429. #if (IsPaleoEpoch) 
  430.   #define  (kBerryPerPlayer,    2)
  431. #else
  432.   #define  (kBerryPerPlayer,    1)
  433. #endif 
  434. #define        (kBerryPerNeutral,            0)
  435.  
  436. #define        (kFishPerPlayer,                14)
  437. #define        (kFishPerNeutral,                0)
  438.  
  439. #define        (kGoldPerPlayer,                2)
  440. #define        (kGoldPerNeutral,                3)
  441.  
  442. #define        (kOilPerPlayer,                0)
  443. #define        (kOilPerNeutral,                0)
  444.  
  445. #define        (kSteelPerPlayer,                2)
  446. #define        (kSteelPerNeutral,            3)
  447.  
  448. #define        (kStonePerPlayer,                1)
  449. #define        (kStonePerNeutral,            1)
  450.  
  451. #define        (kTreePerPlayer,                1)
  452. #define        (kTreePerNeutral,                0)
  453.  
  454.  
  455.  
  456. //////////////////////////////////////////////////////////////////////
  457. // forest definitions
  458. #define        (kForestFreeRadius,            6.0)
  459. #define        (kForestsPerPlayer,            2)
  460. #define        (kForestChaosLevel,            0.1)
  461. #define        (kMaxClumpsPerForest,            2)
  462.  
  463.  
  464. #elif Is6Players
  465. //////////////////////////////////////////////////////////////////////
  466. // 6 PLAYERS...
  467. //////////////////////////////////////////////////////////////////////
  468.  
  469. //////////////////////////////////////////////////////////////////////
  470. // terrain definitions
  471. #define        (kMinIntElevation,                -10)
  472. #define        (kMaxIntElevation,                8)
  473. #define        (kElevationScale,                      1)
  474. #define        (kPercentLand,                    Between(0.45, 0.45))
  475. #define        (kWaterBorder,                    0)
  476. #define        (kRiverWidth,                    8)
  477. #define        (kCoastToDeepWaterPercentage                1.0)
  478. #define        (kHeightMapChaos,                    Between(8, 12))
  479.         
  480. #define        (kMinimumStartPositionToMapEdge        2)
  481. #define        (kOuterPushFromMapCenter            30)
  482. #define        (kInnerPushFromMapCenter             0)
  483.  
  484. //////////////////////////////////////////////////////////////////////
  485. // player definitions
  486. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  487. #define        (kPlayerInnerRadius,            0.7)
  488. #define        (kPlayerOuterRadius,            0.9)
  489. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  490. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  491. #define        (kPlayerLandChaos,            0.8)
  492. #define        (kPlayerLandClumps,            1)
  493. #define        (kPlayerFlatChaos,            0.8)
  494. #define        (kPlayerFlatClumps,            1)
  495. #define        (kPlayerTreePercentage,            0.1)
  496.  
  497.  
  498. //////////////////////////////////////////////////////////////////////
  499. // inner neutral definitions
  500. #define        (kNeutralInnerRadius,            0.05)
  501. #define        (kNeutralOuterRadius,            0.05)
  502. #define        (kNeutralOptimalFactor,            0.7)
  503. #define        (kNumInnerNeutrals,            Between(1, 1))
  504. #define        (kInnerNeutralPercentLand,        0.14)
  505. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  506. #define        (kInnerNeutralTreePercentage,          0.1)
  507. #define        (kInnerNeutralLandChaos,        0.8)
  508. #define        (kInnerNeutralLandClumps,        1)
  509. #define        (kInnerNeutralFlatChaos,        0.8)
  510. #define        (kInnerNeutralFlatClumps,        1)
  511.  
  512.  
  513. //////////////////////////////////////////////////////////////////////
  514. // outer neutral definitions
  515. #define        (kNumOuterNeutrals,            Between(0, 0))
  516. #define        (kOuterNeutralPercentLand,        0.0)
  517. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  518. #define        (kOuterNeutralTreePercentage,          0.1)
  519. #define        (kOuterNeutralLandChaos,        0.8)
  520. #define        (kOuterNeutralLandClumps,        1)
  521. #define        (kOuterNeutralFlatChaos,        0.8)
  522. #define        (kOuterNeutralFlatClumps,        1)
  523.  
  524.  
  525. //////////////////////////////////////////////////////////////////////
  526. // resource definitions
  527. #define        (kMaxResourceElevation,            2)
  528. #define        (kResourceToEdgeDistance,        1)
  529. #define        (kResourceToWaterDistance,        2)
  530.  
  531. #define        (kAnimalPerPlayer,            0)
  532. #define        (kAnimalPerNeutral,            0)
  533.  
  534. #if (IsPaleoEpoch) 
  535.   #define  (kBerryPerPlayer,    2)
  536. #else
  537.   #define  (kBerryPerPlayer,    1)
  538. #endif 
  539. #define        (kBerryPerNeutral,            0)
  540.  
  541. #define        (kFishPerPlayer,                13)
  542. #define        (kFishPerNeutral,                0)
  543.  
  544. #define        (kGoldPerPlayer,                2)
  545. #define        (kGoldPerNeutral,                3)
  546.  
  547. #define        (kOilPerPlayer,                0)
  548. #define        (kOilPerNeutral,                0)
  549.  
  550. #define        (kSteelPerPlayer,                2)
  551. #define        (kSteelPerNeutral,            3)
  552.  
  553. #define        (kStonePerPlayer,                1)
  554. #define        (kStonePerNeutral,            1)
  555.  
  556. #define        (kTreePerPlayer,                1)
  557. #define        (kTreePerNeutral,                0)
  558.  
  559.  
  560. //////////////////////////////////////////////////////////////////////
  561. // forest definitions
  562. #define        (kForestFreeRadius,            5.0)
  563. #define        (kForestsPerPlayer,            2)
  564. #define        (kForestChaosLevel,            0.1)
  565. #define        (kMaxClumpsPerForest,            2)
  566.  
  567.  
  568. #elif Is7Players
  569. //////////////////////////////////////////////////////////////////////
  570. // 7 PLAYERS...
  571. //////////////////////////////////////////////////////////////////////
  572.  
  573. //////////////////////////////////////////////////////////////////////
  574. // terrain definitions
  575. #define        (kMinIntElevation,                -10)
  576. #define        (kMaxIntElevation,                8)
  577. #define        (kElevationScale,                      1)
  578. #define        (kPercentLand,                    Between(0.5, 0.5))
  579. #define        (kWaterBorder,                    0)
  580. #define        (kRiverWidth,                    8)
  581. #define        (kCoastToDeepWaterPercentage                1.0)
  582. #define        (kHeightMapChaos,                    Between(8, 12))
  583.         
  584. #define        (kMinimumStartPositionToMapEdge        2)
  585. #define        (kOuterPushFromMapCenter            30)
  586. #define        (kInnerPushFromMapCenter             0)
  587.                                             
  588.  
  589. //////////////////////////////////////////////////////////////////////
  590. // player definitions
  591. #define        (kMaxAngleBetweenTeamMembers,          40.0)
  592. #define        (kPlayerInnerRadius,            0.7)
  593. #define        (kPlayerOuterRadius,            0.9)
  594. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  595. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  596. #define        (kPlayerLandChaos,            0.8)
  597. #define        (kPlayerLandClumps,            1)
  598. #define        (kPlayerFlatChaos,            0.8)
  599. #define        (kPlayerFlatClumps,            1)
  600. #define        (kPlayerTreePercentage,            0.1)
  601.  
  602. //////////////////////////////////////////////////////////////////////
  603. // inner neutral definitions
  604. #define        (kNeutralInnerRadius,            0.05)
  605. #define        (kNeutralOuterRadius,            0.05)
  606. #define        (kNeutralOptimalFactor,            0.7)
  607. #define        (kNumInnerNeutrals,            Between(1, 1))
  608. #define        (kInnerNeutralPercentLand,        0.12)
  609. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  610. #define        (kInnerNeutralTreePercentage,          0.1)
  611. #define        (kInnerNeutralLandChaos,        0.8)
  612. #define        (kInnerNeutralLandClumps,        1)
  613. #define        (kInnerNeutralFlatChaos,        0.8)
  614. #define        (kInnerNeutralFlatClumps,        1)
  615.  
  616.  
  617. //////////////////////////////////////////////////////////////////////
  618. // outer neutral definitions
  619. #define        (kNumOuterNeutrals,            Between(0, 0))
  620. #define        (kOuterNeutralPercentLand,        0.14)
  621. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  622. #define        (kOuterNeutralTreePercentage,          0.1)
  623. #define        (kOuterNeutralLandChaos,        0.8)
  624. #define        (kOuterNeutralLandClumps,        1)
  625. #define        (kOuterNeutralFlatChaos,        0.8)
  626. #define        (kOuterNeutralFlatClumps,        1)
  627.  
  628.  
  629. //////////////////////////////////////////////////////////////////////
  630. // resource definitions
  631. #define        (kMaxResourceElevation,            2)
  632. #define        (kResourceToEdgeDistance,        1)
  633. #define        (kResourceToWaterDistance,        2)
  634.  
  635. #define        (kAnimalPerPlayer,            0)
  636. #define        (kAnimalPerNeutral,            0)
  637.  
  638. #if (IsPaleoEpoch) 
  639.   #define  (kBerryPerPlayer,    2)
  640. #else
  641.   #define  (kBerryPerPlayer,    1)
  642. #endif 
  643. #define        (kBerryPerNeutral,            0)
  644.  
  645. #define        (kFishPerPlayer,                13)
  646. #define        (kFishPerNeutral,                0)
  647.  
  648. #define        (kGoldPerPlayer,                2)
  649. #define        (kGoldPerNeutral,                2)
  650.  
  651. #define        (kOilPerPlayer,                0)
  652. #define        (kOilPerNeutral,                0)
  653.  
  654. #define        (kSteelPerPlayer,                2)
  655. #define        (kSteelPerNeutral,            2)
  656.  
  657. #define        (kStonePerPlayer,                1)
  658. #define        (kStonePerNeutral,            1)
  659.  
  660. #define        (kTreePerPlayer,                1)
  661. #define        (kTreePerNeutral,                0)
  662.  
  663.  
  664. //////////////////////////////////////////////////////////////////////
  665. // forest definitions
  666. #define        (kForestFreeRadius,            5.0)
  667. #define        (kForestsPerPlayer,            2)
  668. #define        (kForestChaosLevel,            0.1)
  669. #define        (kMaxClumpsPerForest,            2)
  670.  
  671.  
  672. #elif Is8Players
  673. //////////////////////////////////////////////////////////////////////
  674. // 8 PLAYERS...
  675. //////////////////////////////////////////////////////////////////////
  676.  
  677. //////////////////////////////////////////////////////////////////////
  678. // terrain definitions
  679. #define        (kMinIntElevation,                -10)
  680. #define        (kMaxIntElevation,                8)
  681. #define        (kElevationScale,                      1)
  682. #define        (kPercentLand,                    Between(0.5, 0.5))
  683. #define        (kWaterBorder,                    0)
  684. #define        (kRiverWidth,                    8)
  685. #define        (kCoastToDeepWaterPercentage                1.0)
  686. #define        (kHeightMapChaos,                    Between(8, 12))
  687.         
  688. #define        (kMinimumStartPositionToMapEdge        2)
  689. #define        (kOuterPushFromMapCenter            30)
  690. #define        (kInnerPushFromMapCenter             0)
  691.  
  692. //////////////////////////////////////////////////////////////////////
  693. // player definitions
  694. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  695. #define        (kPlayerInnerRadius,            0.7)
  696. #define        (kPlayerOuterRadius,            0.9)
  697. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  698. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  699. #define        (kPlayerLandChaos,            0.8)
  700. #define        (kPlayerLandClumps,            1)
  701. #define        (kPlayerFlatChaos,            0.8)
  702. #define        (kPlayerFlatClumps,            1)
  703. #define        (kPlayerTreePercentage,            0.1)
  704.  
  705.  
  706. //////////////////////////////////////////////////////////////////////
  707. // inner neutral definitions
  708. #define        (kNeutralInnerRadius,            0.05)
  709. #define        (kNeutralOuterRadius,            0.05)
  710. #define        (kNeutralOptimalFactor,            0.7)
  711. #define        (kNumInnerNeutrals,            Between(1, 1))
  712. #define        (kInnerNeutralPercentLand,        0.11)
  713. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  714. #define        (kInnerNeutralTreePercentage,          0.1)
  715. #define        (kInnerNeutralLandChaos,        0.8)
  716. #define        (kInnerNeutralLandClumps,        1)
  717. #define        (kInnerNeutralFlatChaos,        0.8)
  718. #define        (kInnerNeutralFlatClumps,        1)
  719.  
  720.  
  721. //////////////////////////////////////////////////////////////////////
  722. // outer neutral definitions
  723. #define        (kNumOuterNeutrals,            Between(0, 0))
  724. #define        (kOuterNeutralPercentLand,        0.35)
  725. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  726. #define        (kOuterNeutralTreePercentage,          0.1)
  727. #define        (kOuterNeutralLandChaos,        0.8)
  728. #define        (kOuterNeutralLandClumps,        1)
  729. #define        (kOuterNeutralFlatChaos,        0.8)
  730. #define        (kOuterNeutralFlatClumps,        1)
  731.  
  732.  
  733. //////////////////////////////////////////////////////////////////////
  734. // resource definitions
  735. #define        (kMaxResourceElevation,            2)
  736. #define        (kResourceToEdgeDistance,        2)
  737. #define        (kResourceToWaterDistance,        2)
  738.  
  739. #define        (kAnimalPerPlayer,            0)
  740. #define        (kAnimalPerNeutral,            0)
  741.  
  742. #if (IsPaleoEpoch) 
  743.   #define  (kBerryPerPlayer,    2)
  744. #else
  745.   #define  (kBerryPerPlayer,    1)
  746. #endif 
  747. #define        (kBerryPerNeutral,            0)
  748.  
  749. #define        (kFishPerPlayer,                10)
  750. #define        (kFishPerNeutral,                0)
  751.  
  752. #define        (kGoldPerPlayer,                2)
  753. #define        (kGoldPerNeutral,                2)
  754.  
  755. #define        (kOilPerPlayer,                0)
  756. #define        (kOilPerNeutral,                0)
  757.  
  758. #define        (kSteelPerPlayer,                2)
  759. #define        (kSteelPerNeutral,            2)
  760.  
  761. #define        (kStonePerPlayer,                1)
  762. #define        (kStonePerNeutral,            1)
  763.  
  764. #define        (kTreePerPlayer,                1)
  765. #define        (kTreePerNeutral,                0)
  766.  
  767. //////////////////////////////////////////////////////////////////////
  768. // forest definitions
  769. #define        (kForestFreeRadius,            5.0)
  770. #define        (kForestsPerPlayer,            2)
  771. #define        (kForestChaosLevel,            0.1)
  772. #define        (kMaxClumpsPerForest,            2)
  773.  
  774.  
  775. #elif Is9Players
  776. //////////////////////////////////////////////////////////////////////
  777. // 9 PLAYERS...
  778. //////////////////////////////////////////////////////////////////////
  779.  
  780. //////////////////////////////////////////////////////////////////////
  781. // terrain definitions
  782. #define        (kMinIntElevation,                -10)
  783. #define        (kMaxIntElevation,                12)
  784. #define        (kElevationScale,                      1)
  785. #define        (kPercentLand,                    Between(0.5, 0.5))
  786. #define        (kWaterBorder,                    0)
  787. #define        (kRiverWidth,                    10)
  788. #define        (kCoastToDeepWaterPercentage                1.0)
  789. #define        (kHeightMapChaos,                    Between(10, 15))
  790.         
  791. #define        (kMinimumStartPositionToMapEdge        4)
  792. #define        (kOuterPushFromMapCenter            10)
  793. #define        (kInnerPushFromMapCenter             0)
  794.  
  795. //////////////////////////////////////////////////////////////////////
  796. // player definitions
  797. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  798. #define        (kPlayerInnerRadius,            0.4)
  799. #define        (kPlayerOuterRadius,            0.9)
  800. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  801. #define        (kPlayerPercentFlat,            Between(0.75, 0.75))
  802. #define        (kPlayerLandChaos,            0.8)
  803. #define        (kPlayerLandClumps,            1)
  804. #define        (kPlayerFlatChaos,            0.8)
  805. #define        (kPlayerFlatClumps,            1)
  806. #define        (kPlayerTreePercentage,            0.06)
  807.  
  808.  
  809. //////////////////////////////////////////////////////////////////////
  810. // inner neutral definitions
  811. #define        (kNeutralInnerRadius,            0.05)
  812. #define        (kNeutralOuterRadius,            0.4)
  813. #define        (kNeutralOptimalFactor,            0.7)
  814. #define        (kNumInnerNeutrals,            Between(0, 0))
  815. #define        (kInnerNeutralPercentLand,        0.11)
  816. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  817. #define        (kInnerNeutralTreePercentage,          0.05)
  818. #define        (kInnerNeutralLandChaos,        0.8)
  819. #define        (kInnerNeutralLandClumps,        2)
  820. #define        (kInnerNeutralFlatChaos,        0.8)
  821. #define        (kInnerNeutralFlatClumps,        2)
  822.  
  823.  
  824. //////////////////////////////////////////////////////////////////////
  825. // outer neutral definitions
  826. #define        (kNumOuterNeutrals,            Between(0, 0))
  827. #define        (kOuterNeutralPercentLand,        0.35)
  828. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  829. #define        (kOuterNeutralTreePercentage,          0.05)
  830. #define        (kOuterNeutralLandChaos,        0.8)
  831. #define        (kOuterNeutralLandClumps,        2)
  832. #define        (kOuterNeutralFlatChaos,        0.8)
  833. #define        (kOuterNeutralFlatClumps,        2)
  834.  
  835.  
  836. //////////////////////////////////////////////////////////////////////
  837. // resource definitions
  838. #define        (kMaxResourceElevation,            2)
  839. #define        (kResourceToEdgeDistance,        2)
  840. #define        (kResourceToWaterDistance,        2)
  841.  
  842. #define        (kAnimalPerPlayer,            0)
  843. #define        (kAnimalPerNeutral,            0)
  844.  
  845. #if (IsPaleoEpoch) 
  846.   #define  (kBerryPerPlayer,    2)
  847. #else
  848.   #define  (kBerryPerPlayer,    1)
  849. #endif 
  850. #define        (kBerryPerNeutral,            0)
  851.  
  852. #define        (kFishPerPlayer,                9)
  853. #define        (kFishPerNeutral,                0)
  854.  
  855. #define        (kGoldPerPlayer,                2)
  856. #define        (kGoldPerNeutral,                0)
  857.  
  858. #define        (kOilPerPlayer,                0)
  859. #define        (kOilPerNeutral,                0)
  860.  
  861. #define        (kSteelPerPlayer,                2)
  862. #define        (kSteelPerNeutral,            0)
  863.  
  864. #define        (kStonePerPlayer,                1)
  865. #define        (kStonePerNeutral,            0)
  866.  
  867. #define        (kTreePerPlayer,                0)
  868. #define        (kTreePerNeutral,                0)
  869.  
  870. //////////////////////////////////////////////////////////////////////
  871. // forest definitions
  872. #define        (kForestFreeRadius,            5.0)
  873. #define        (kForestsPerPlayer,            2)
  874. #define        (kForestChaosLevel,            0.1)
  875. #define        (kMaxClumpsPerForest,            2)
  876.  
  877.  
  878. #elif Is10Players
  879. //////////////////////////////////////////////////////////////////////
  880. // 10 PLAYERS...
  881. //////////////////////////////////////////////////////////////////////
  882.  
  883. //////////////////////////////////////////////////////////////////////
  884. // terrain definitions
  885. #define        (kMinIntElevation,                -10)
  886. #define        (kMaxIntElevation,                12)
  887. #define        (kElevationScale,                      1)
  888. #define        (kPercentLand,                    Between(0.5, 0.5))
  889. #define        (kWaterBorder,                    0)
  890. #define        (kRiverWidth,                    10)
  891. #define        (kCoastToDeepWaterPercentage                1.0)
  892. #define        (kHeightMapChaos,                    Between(10, 15))
  893.         
  894. #define        (kMinimumStartPositionToMapEdge        4)
  895. #define        (kOuterPushFromMapCenter            10)
  896. #define        (kInnerPushFromMapCenter             0)
  897.  
  898. //////////////////////////////////////////////////////////////////////
  899. // player definitions
  900. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  901. #define        (kPlayerInnerRadius,            0.4)
  902. #define        (kPlayerOuterRadius,            0.9)
  903. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  904. #define        (kPlayerPercentFlat,            Between(0.75, 0.75))
  905. #define        (kPlayerLandChaos,            0.8)
  906. #define        (kPlayerLandClumps,            1)
  907. #define        (kPlayerFlatChaos,            0.8)
  908. #define        (kPlayerFlatClumps,            1)
  909. #define        (kPlayerTreePercentage,            0.06)
  910.  
  911.  
  912. //////////////////////////////////////////////////////////////////////
  913. // inner neutral definitions
  914. #define        (kNeutralInnerRadius,            0.05)
  915. #define        (kNeutralOuterRadius,            0.4)
  916. #define        (kNeutralOptimalFactor,            0.7)
  917. #define        (kNumInnerNeutrals,            Between(0, 0))
  918. #define        (kInnerNeutralPercentLand,        0.11)
  919. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  920. #define        (kInnerNeutralTreePercentage,          0.05)
  921. #define        (kInnerNeutralLandChaos,        0.8)
  922. #define        (kInnerNeutralLandClumps,        2)
  923. #define        (kInnerNeutralFlatChaos,        0.8)
  924. #define        (kInnerNeutralFlatClumps,        2)
  925.  
  926.  
  927. //////////////////////////////////////////////////////////////////////
  928. // outer neutral definitions
  929. #define        (kNumOuterNeutrals,            Between(0, 0))
  930. #define        (kOuterNeutralPercentLand,        0.35)
  931. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  932. #define        (kOuterNeutralTreePercentage,          0.05)
  933. #define        (kOuterNeutralLandChaos,        0.8)
  934. #define        (kOuterNeutralLandClumps,        2)
  935. #define        (kOuterNeutralFlatChaos,        0.8)
  936. #define        (kOuterNeutralFlatClumps,        2)
  937.  
  938.  
  939. //////////////////////////////////////////////////////////////////////
  940. // resource definitions
  941. #define        (kMaxResourceElevation,            2)
  942. #define        (kResourceToEdgeDistance,        2)
  943. #define        (kResourceToWaterDistance,        2)
  944.  
  945. #define        (kAnimalPerPlayer,            0)
  946. #define        (kAnimalPerNeutral,            0)
  947.  
  948. #define        (kBerryPerPlayer,                0)
  949. #define        (kBerryPerNeutral,            0)
  950.  
  951. #define        (kFishPerPlayer,                9)
  952. #define        (kFishPerNeutral,                0)
  953.  
  954. #define        (kGoldPerPlayer,                2)
  955. #define        (kGoldPerNeutral,                0)
  956.  
  957. #define        (kOilPerPlayer,                0)
  958. #define        (kOilPerNeutral,                0)
  959.  
  960. #define        (kSteelPerPlayer,                2)
  961. #define        (kSteelPerNeutral,            0)
  962.  
  963. #define        (kStonePerPlayer,                1)
  964. #define        (kStonePerNeutral,            0)
  965.  
  966. #define        (kTreePerPlayer,                0)
  967. #define        (kTreePerNeutral,                0)
  968.  
  969. //////////////////////////////////////////////////////////////////////
  970. // forest definitions
  971. #define        (kForestFreeRadius,            5.0)
  972. #define        (kForestsPerPlayer,            2)
  973. #define        (kForestChaosLevel,            0.1)
  974. #define        (kMaxClumpsPerForest,            2)
  975.  
  976.  
  977. #elif Is11Players
  978. //////////////////////////////////////////////////////////////////////
  979. // 11 PLAYERS...
  980. //////////////////////////////////////////////////////////////////////
  981.  
  982. //////////////////////////////////////////////////////////////////////
  983. // terrain definitions
  984. #define        (kMinIntElevation,                -10)
  985. #define        (kMaxIntElevation,                12)
  986. #define        (kElevationScale,                      1)
  987. #define        (kPercentLand,                    Between(0.5, 0.5))
  988. #define        (kWaterBorder,                    0)
  989. #define        (kRiverWidth,                    10)
  990. #define        (kCoastToDeepWaterPercentage                1.0)
  991. #define        (kHeightMapChaos,                    Between(10, 15))
  992.         
  993. #define        (kMinimumStartPositionToMapEdge        4)
  994. #define        (kOuterPushFromMapCenter            10)
  995. #define        (kInnerPushFromMapCenter             0)
  996.  
  997. //////////////////////////////////////////////////////////////////////
  998. // player definitions
  999. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  1000. #define        (kPlayerInnerRadius,            0.3)
  1001. #define        (kPlayerOuterRadius,            0.9)
  1002. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1003. #define        (kPlayerPercentFlat,            Between(0.75, 0.75))
  1004. #define        (kPlayerLandChaos,            0.8)
  1005. #define        (kPlayerLandClumps,            1)
  1006. #define        (kPlayerFlatChaos,            0.8)
  1007. #define        (kPlayerFlatClumps,            1)
  1008. #define        (kPlayerTreePercentage,            0.06)
  1009.  
  1010.  
  1011. //////////////////////////////////////////////////////////////////////
  1012. // inner neutral definitions
  1013. #define        (kNeutralInnerRadius,            0.05)
  1014. #define        (kNeutralOuterRadius,            0.4)
  1015. #define        (kNeutralOptimalFactor,            0.7)
  1016. #define        (kNumInnerNeutrals,            Between(0, 0))
  1017. #define        (kInnerNeutralPercentLand,        0.11)
  1018. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1019. #define        (kInnerNeutralTreePercentage,          0.05)
  1020. #define        (kInnerNeutralLandChaos,        0.8)
  1021. #define        (kInnerNeutralLandClumps,        2)
  1022. #define        (kInnerNeutralFlatChaos,        0.8)
  1023. #define        (kInnerNeutralFlatClumps,        2)
  1024.  
  1025.  
  1026. //////////////////////////////////////////////////////////////////////
  1027. // outer neutral definitions
  1028. #define        (kNumOuterNeutrals,            Between(0, 0))
  1029. #define        (kOuterNeutralPercentLand,        0.35)
  1030. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1031. #define        (kOuterNeutralTreePercentage,          0.05)
  1032. #define        (kOuterNeutralLandChaos,        0.8)
  1033. #define        (kOuterNeutralLandClumps,        2)
  1034. #define        (kOuterNeutralFlatChaos,        0.8)
  1035. #define        (kOuterNeutralFlatClumps,        2)
  1036.  
  1037.  
  1038. //////////////////////////////////////////////////////////////////////
  1039. // resource definitions
  1040. #define        (kMaxResourceElevation,            2)
  1041. #define        (kResourceToEdgeDistance,        2)
  1042. #define        (kResourceToWaterDistance,        2)
  1043.  
  1044. #define        (kAnimalPerPlayer,            0)
  1045. #define        (kAnimalPerNeutral,            0)
  1046.  
  1047. #define        (kBerryPerPlayer,                0)
  1048. #define        (kBerryPerNeutral,            0)
  1049.  
  1050. #define        (kFishPerPlayer,                9)
  1051. #define        (kFishPerNeutral,                0)
  1052.  
  1053. #define        (kGoldPerPlayer,                2)
  1054. #define        (kGoldPerNeutral,                0)
  1055.  
  1056. #define        (kOilPerPlayer,                0)
  1057. #define        (kOilPerNeutral,                0)
  1058.  
  1059. #define        (kSteelPerPlayer,                2)
  1060. #define        (kSteelPerNeutral,            0)
  1061.  
  1062. #define        (kStonePerPlayer,                1)
  1063. #define        (kStonePerNeutral,            0)
  1064.  
  1065. #define        (kTreePerPlayer,                0)
  1066. #define        (kTreePerNeutral,                0)
  1067.  
  1068. //////////////////////////////////////////////////////////////////////
  1069. // forest definitions
  1070. #define        (kForestFreeRadius,            5.0)
  1071. #define        (kForestsPerPlayer,            2)
  1072. #define        (kForestChaosLevel,            0.1)
  1073. #define        (kMaxClumpsPerForest,            2)
  1074.  
  1075.  
  1076. #elif Is12Players
  1077. //////////////////////////////////////////////////////////////////////
  1078. // 12 PLAYERS...
  1079. //////////////////////////////////////////////////////////////////////
  1080.  
  1081. //////////////////////////////////////////////////////////////////////
  1082. // terrain definitions
  1083. #define        (kMinIntElevation,                -10)
  1084. #define        (kMaxIntElevation,                12)
  1085. #define        (kElevationScale,                      1)
  1086. #define        (kPercentLand,                    Between(0.5, 0.5))
  1087. #define        (kWaterBorder,                    0)
  1088. #define        (kRiverWidth,                    9)
  1089. #define        (kCoastToDeepWaterPercentage                1.0)
  1090. #define        (kHeightMapChaos,                    Between(10, 15))
  1091.         
  1092. #define        (kMinimumStartPositionToMapEdge        4)
  1093. #define        (kOuterPushFromMapCenter            10)
  1094. #define        (kInnerPushFromMapCenter             0)
  1095.  
  1096. //////////////////////////////////////////////////////////////////////
  1097. // player definitions
  1098. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  1099. #define        (kPlayerInnerRadius,            0.2)
  1100. #define        (kPlayerOuterRadius,            0.9)
  1101. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1102. #define        (kPlayerPercentFlat,            Between(0.75, 0.75))
  1103. #define        (kPlayerLandChaos,            0.8)
  1104. #define        (kPlayerLandClumps,            1)
  1105. #define        (kPlayerFlatChaos,            0.8)
  1106. #define        (kPlayerFlatClumps,            1)
  1107. #define        (kPlayerTreePercentage,            0.06)
  1108.  
  1109.  
  1110. //////////////////////////////////////////////////////////////////////
  1111. // inner neutral definitions
  1112. #define        (kNeutralInnerRadius,            0.05)
  1113. #define        (kNeutralOuterRadius,            0.4)
  1114. #define        (kNeutralOptimalFactor,            0.7)
  1115. #define        (kNumInnerNeutrals,            Between(0, 0))
  1116. #define        (kInnerNeutralPercentLand,        0.11)
  1117. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1118. #define        (kInnerNeutralTreePercentage,          0.05)
  1119. #define        (kInnerNeutralLandChaos,        0.8)
  1120. #define        (kInnerNeutralLandClumps,        2)
  1121. #define        (kInnerNeutralFlatChaos,        0.8)
  1122. #define        (kInnerNeutralFlatClumps,        2)
  1123.  
  1124.  
  1125. //////////////////////////////////////////////////////////////////////
  1126. // outer neutral definitions
  1127. #define        (kNumOuterNeutrals,            Between(0, 0))
  1128. #define        (kOuterNeutralPercentLand,        0.35)
  1129. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1130. #define        (kOuterNeutralTreePercentage,          0.05)
  1131. #define        (kOuterNeutralLandChaos,        0.8)
  1132. #define        (kOuterNeutralLandClumps,        2)
  1133. #define        (kOuterNeutralFlatChaos,        0.8)
  1134. #define        (kOuterNeutralFlatClumps,        2)
  1135.  
  1136.  
  1137. //////////////////////////////////////////////////////////////////////
  1138. // resource definitions
  1139. #define        (kMaxResourceElevation,            2)
  1140. #define        (kResourceToEdgeDistance,        2)
  1141. #define        (kResourceToWaterDistance,        2)
  1142.  
  1143. #define        (kAnimalPerPlayer,            0)
  1144. #define        (kAnimalPerNeutral,            0)
  1145.  
  1146. #define        (kBerryPerPlayer,                0)
  1147. #define        (kBerryPerNeutral,            0)
  1148.  
  1149. #define        (kFishPerPlayer,                8)
  1150. #define        (kFishPerNeutral,                0)
  1151.  
  1152. #define        (kGoldPerPlayer,                2)
  1153. #define        (kGoldPerNeutral,                0)
  1154.  
  1155. #define        (kOilPerPlayer,                0)
  1156. #define        (kOilPerNeutral,                0)
  1157.  
  1158. #define        (kSteelPerPlayer,                2)
  1159. #define        (kSteelPerNeutral,            0)
  1160.  
  1161. #define        (kStonePerPlayer,                1)
  1162. #define        (kStonePerNeutral,            0)
  1163.  
  1164. #define        (kTreePerPlayer,                0)
  1165. #define        (kTreePerNeutral,                0)
  1166.  
  1167. //////////////////////////////////////////////////////////////////////
  1168. // forest definitions
  1169. #define        (kForestFreeRadius,            5.0)
  1170. #define        (kForestsPerPlayer,            2)
  1171. #define        (kForestChaosLevel,            0.1)
  1172. #define        (kMaxClumpsPerForest,            2)
  1173.  
  1174.  
  1175. #elif Is13Players
  1176. //////////////////////////////////////////////////////////////////////
  1177. // 13 PLAYERS...
  1178. //////////////////////////////////////////////////////////////////////
  1179.  
  1180. //////////////////////////////////////////////////////////////////////
  1181. // terrain definitions
  1182. #define        (kMinIntElevation,                -10)
  1183. #define        (kMaxIntElevation,                12)
  1184. #define        (kElevationScale,                      1)
  1185. #define        (kPercentLand,                    Between(0.5, 0.5))
  1186. #define        (kWaterBorder,                    0)
  1187. #define        (kRiverWidth,                    8)
  1188. #define        (kCoastToDeepWaterPercentage                1.0)
  1189. #define        (kHeightMapChaos,                    Between(10, 15))
  1190.         
  1191. #define        (kMinimumStartPositionToMapEdge        4)
  1192. #define        (kOuterPushFromMapCenter            10)
  1193. #define        (kInnerPushFromMapCenter             0)
  1194.  
  1195. //////////////////////////////////////////////////////////////////////
  1196. // player definitions
  1197. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  1198. #define        (kPlayerInnerRadius,            0.1)
  1199. #define        (kPlayerOuterRadius,            0.9)
  1200. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1201. #define        (kPlayerPercentFlat,            Between(0.75, 0.75))
  1202. #define        (kPlayerLandChaos,            0.8)
  1203. #define        (kPlayerLandClumps,            1)
  1204. #define        (kPlayerFlatChaos,            0.8)
  1205. #define        (kPlayerFlatClumps,            1)
  1206. #define        (kPlayerTreePercentage,            0.06)
  1207.  
  1208.  
  1209. //////////////////////////////////////////////////////////////////////
  1210. // inner neutral definitions
  1211. #define        (kNeutralInnerRadius,            0.05)
  1212. #define        (kNeutralOuterRadius,            0.4)
  1213. #define        (kNeutralOptimalFactor,            0.7)
  1214. #define        (kNumInnerNeutrals,            Between(0, 0))
  1215. #define        (kInnerNeutralPercentLand,        0.11)
  1216. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1217. #define        (kInnerNeutralTreePercentage,          0.05)
  1218. #define        (kInnerNeutralLandChaos,        0.8)
  1219. #define        (kInnerNeutralLandClumps,        2)
  1220. #define        (kInnerNeutralFlatChaos,        0.8)
  1221. #define        (kInnerNeutralFlatClumps,        2)
  1222.  
  1223.  
  1224. //////////////////////////////////////////////////////////////////////
  1225. // outer neutral definitions
  1226. #define        (kNumOuterNeutrals,            Between(0, 0))
  1227. #define        (kOuterNeutralPercentLand,        0.35)
  1228. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1229. #define        (kOuterNeutralTreePercentage,          0.05)
  1230. #define        (kOuterNeutralLandChaos,        0.8)
  1231. #define        (kOuterNeutralLandClumps,        2)
  1232. #define        (kOuterNeutralFlatChaos,        0.8)
  1233. #define        (kOuterNeutralFlatClumps,        2)
  1234.  
  1235.  
  1236. //////////////////////////////////////////////////////////////////////
  1237. // resource definitions
  1238. #define        (kMaxResourceElevation,            2)
  1239. #define        (kResourceToEdgeDistance,        2)
  1240. #define        (kResourceToWaterDistance,        2)
  1241.  
  1242. #define        (kAnimalPerPlayer,            0)
  1243. #define        (kAnimalPerNeutral,            0)
  1244.  
  1245. #define        (kBerryPerPlayer,                0)
  1246. #define        (kBerryPerNeutral,            0)
  1247.  
  1248. #define        (kFishPerPlayer,                8)
  1249. #define        (kFishPerNeutral,                0)
  1250.  
  1251. #define        (kGoldPerPlayer,                2)
  1252. #define        (kGoldPerNeutral,                0)
  1253.  
  1254. #define        (kOilPerPlayer,                0)
  1255. #define        (kOilPerNeutral,                0)
  1256.  
  1257. #define        (kSteelPerPlayer,                2)
  1258. #define        (kSteelPerNeutral,            0)
  1259.  
  1260. #define        (kStonePerPlayer,                1)
  1261. #define        (kStonePerNeutral,            0)
  1262.  
  1263. #define        (kTreePerPlayer,                0)
  1264. #define        (kTreePerNeutral,                0)
  1265.  
  1266. //////////////////////////////////////////////////////////////////////
  1267. // forest definitions
  1268. #define        (kForestFreeRadius,            5.0)
  1269. #define        (kForestsPerPlayer,            2)
  1270. #define        (kForestChaosLevel,            0.1)
  1271. #define        (kMaxClumpsPerForest,            2)
  1272.  
  1273.  
  1274. #elif Is14Players
  1275. //////////////////////////////////////////////////////////////////////
  1276. // 14 PLAYERS...
  1277. //////////////////////////////////////////////////////////////////////
  1278.  
  1279. //////////////////////////////////////////////////////////////////////
  1280. // terrain definitions
  1281. #define        (kMinIntElevation,                -10)
  1282. #define        (kMaxIntElevation,                12)
  1283. #define        (kElevationScale,                      1)
  1284. #define        (kPercentLand,                    Between(0.5, 0.5))
  1285. #define        (kWaterBorder,                    0)
  1286. #define        (kRiverWidth,                    7)
  1287. #define        (kCoastToDeepWaterPercentage                1.0)
  1288. #define        (kHeightMapChaos,                    Between(10, 15))
  1289.         
  1290. #define        (kMinimumStartPositionToMapEdge        4)
  1291. #define        (kOuterPushFromMapCenter            10)
  1292. #define        (kInnerPushFromMapCenter             0)
  1293.  
  1294. //////////////////////////////////////////////////////////////////////
  1295. // player definitions
  1296. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  1297. #define        (kPlayerInnerRadius,            0.01)
  1298. #define        (kPlayerOuterRadius,            0.9)
  1299. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1300. #define        (kPlayerPercentFlat,            Between(0.75, 0.75))
  1301. #define        (kPlayerLandChaos,            0.8)
  1302. #define        (kPlayerLandClumps,            1)
  1303. #define        (kPlayerFlatChaos,            0.8)
  1304. #define        (kPlayerFlatClumps,            1)
  1305. #define        (kPlayerTreePercentage,            0.06)
  1306.  
  1307.  
  1308. //////////////////////////////////////////////////////////////////////
  1309. // inner neutral definitions
  1310. #define        (kNeutralInnerRadius,            0.05)
  1311. #define        (kNeutralOuterRadius,            0.4)
  1312. #define        (kNeutralOptimalFactor,            0.7)
  1313. #define        (kNumInnerNeutrals,            Between(0, 0))
  1314. #define        (kInnerNeutralPercentLand,        0.11)
  1315. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1316. #define        (kInnerNeutralTreePercentage,          0.05)
  1317. #define        (kInnerNeutralLandChaos,        0.8)
  1318. #define        (kInnerNeutralLandClumps,        2)
  1319. #define        (kInnerNeutralFlatChaos,        0.8)
  1320. #define        (kInnerNeutralFlatClumps,        2)
  1321.  
  1322.  
  1323. //////////////////////////////////////////////////////////////////////
  1324. // outer neutral definitions
  1325. #define        (kNumOuterNeutrals,            Between(0, 0))
  1326. #define        (kOuterNeutralPercentLand,        0.35)
  1327. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1328. #define        (kOuterNeutralTreePercentage,          0.05)
  1329. #define        (kOuterNeutralLandChaos,        0.8)
  1330. #define        (kOuterNeutralLandClumps,        2)
  1331. #define        (kOuterNeutralFlatChaos,        0.8)
  1332. #define        (kOuterNeutralFlatClumps,        2)
  1333.  
  1334.  
  1335. //////////////////////////////////////////////////////////////////////
  1336. // resource definitions
  1337. #define        (kMaxResourceElevation,            2)
  1338. #define        (kResourceToEdgeDistance,        2)
  1339. #define        (kResourceToWaterDistance,        2)
  1340.  
  1341. #define        (kAnimalPerPlayer,            0)
  1342. #define        (kAnimalPerNeutral,            0)
  1343.  
  1344. #define        (kBerryPerPlayer,                0)
  1345. #define        (kBerryPerNeutral,            0)
  1346.  
  1347. #define        (kFishPerPlayer,                8)
  1348. #define        (kFishPerNeutral,                0)
  1349.  
  1350. #define        (kGoldPerPlayer,                2)
  1351. #define        (kGoldPerNeutral,                0)
  1352.  
  1353. #define        (kOilPerPlayer,                0)
  1354. #define        (kOilPerNeutral,                0)
  1355.  
  1356. #define        (kSteelPerPlayer,                2)
  1357. #define        (kSteelPerNeutral,            0)
  1358.  
  1359. #define        (kStonePerPlayer,                1)
  1360. #define        (kStonePerNeutral,            0)
  1361.  
  1362. #define        (kTreePerPlayer,                0)
  1363. #define        (kTreePerNeutral,                0)
  1364.  
  1365. //////////////////////////////////////////////////////////////////////
  1366. // forest definitions
  1367. #define        (kForestFreeRadius,            5.0)
  1368. #define        (kForestsPerPlayer,            2)
  1369. #define        (kForestChaosLevel,            0.1)
  1370. #define        (kMaxClumpsPerForest,            2)
  1371.  
  1372.  
  1373. #elif Is15Players
  1374. //////////////////////////////////////////////////////////////////////
  1375. // 15 PLAYERS...
  1376. //////////////////////////////////////////////////////////////////////
  1377.  
  1378. //////////////////////////////////////////////////////////////////////
  1379. // terrain definitions
  1380. #define        (kMinIntElevation,                -10)
  1381. #define        (kMaxIntElevation,                12)
  1382. #define        (kElevationScale,                      1)
  1383. #define        (kPercentLand,                    Between(0.5, 0.5))
  1384. #define        (kWaterBorder,                    0)
  1385. #define        (kRiverWidth,                    6)
  1386. #define        (kCoastToDeepWaterPercentage                1.0)
  1387. #define        (kHeightMapChaos,                    Between(10, 15))
  1388.         
  1389. #define        (kMinimumStartPositionToMapEdge        4)
  1390. #define        (kOuterPushFromMapCenter            10)
  1391. #define        (kInnerPushFromMapCenter             0)
  1392.  
  1393. //////////////////////////////////////////////////////////////////////
  1394. // player definitions
  1395. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  1396. #define        (kPlayerInnerRadius,            0.01)
  1397. #define        (kPlayerOuterRadius,            0.9)
  1398. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1399. #define        (kPlayerPercentFlat,            Between(0.75, 0.75))
  1400. #define        (kPlayerLandChaos,            0.8)
  1401. #define        (kPlayerLandClumps,            1)
  1402. #define        (kPlayerFlatChaos,            0.8)
  1403. #define        (kPlayerFlatClumps,            1)
  1404. #define        (kPlayerTreePercentage,            0.06)
  1405.  
  1406.  
  1407. //////////////////////////////////////////////////////////////////////
  1408. // inner neutral definitions
  1409. #define        (kNeutralInnerRadius,            0.05)
  1410. #define        (kNeutralOuterRadius,            0.4)
  1411. #define        (kNeutralOptimalFactor,            0.7)
  1412. #define        (kNumInnerNeutrals,            Between(0, 0))
  1413. #define        (kInnerNeutralPercentLand,        0.11)
  1414. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1415. #define        (kInnerNeutralTreePercentage,          0.05)
  1416. #define        (kInnerNeutralLandChaos,        0.8)
  1417. #define        (kInnerNeutralLandClumps,        2)
  1418. #define        (kInnerNeutralFlatChaos,        0.8)
  1419. #define        (kInnerNeutralFlatClumps,        2)
  1420.  
  1421.  
  1422. //////////////////////////////////////////////////////////////////////
  1423. // outer neutral definitions
  1424. #define        (kNumOuterNeutrals,            Between(0, 0))
  1425. #define        (kOuterNeutralPercentLand,        0.35)
  1426. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1427. #define        (kOuterNeutralTreePercentage,          0.05)
  1428. #define        (kOuterNeutralLandChaos,        0.8)
  1429. #define        (kOuterNeutralLandClumps,        2)
  1430. #define        (kOuterNeutralFlatChaos,        0.8)
  1431. #define        (kOuterNeutralFlatClumps,        2)
  1432.  
  1433.  
  1434. //////////////////////////////////////////////////////////////////////
  1435. // resource definitions
  1436. #define        (kMaxResourceElevation,            2)
  1437. #define        (kResourceToEdgeDistance,        2)
  1438. #define        (kResourceToWaterDistance,        2)
  1439.  
  1440. #define        (kAnimalPerPlayer,            0)
  1441. #define        (kAnimalPerNeutral,            0)
  1442.  
  1443. #define        (kBerryPerPlayer,                0)
  1444. #define        (kBerryPerNeutral,            0)
  1445.  
  1446. #define        (kFishPerPlayer,                7)
  1447. #define        (kFishPerNeutral,                0)
  1448.  
  1449. #define        (kGoldPerPlayer,                2)
  1450. #define        (kGoldPerNeutral,                0)
  1451.  
  1452. #define        (kOilPerPlayer,                0)
  1453. #define        (kOilPerNeutral,                0)
  1454.  
  1455. #define        (kSteelPerPlayer,                2)
  1456. #define        (kSteelPerNeutral,            0)
  1457.  
  1458. #define        (kStonePerPlayer,                1)
  1459. #define        (kStonePerNeutral,            0)
  1460.  
  1461. #define        (kTreePerPlayer,                0)
  1462. #define        (kTreePerNeutral,                0)
  1463.  
  1464. //////////////////////////////////////////////////////////////////////
  1465. // forest definitions
  1466. #define        (kForestFreeRadius,            5.0)
  1467. #define        (kForestsPerPlayer,            2)
  1468. #define        (kForestChaosLevel,            0.1)
  1469. #define        (kMaxClumpsPerForest,            2)
  1470.  
  1471.  
  1472. #elif Is16Players
  1473. //////////////////////////////////////////////////////////////////////
  1474. // 16 PLAYERS...
  1475. //////////////////////////////////////////////////////////////////////
  1476.  
  1477. //////////////////////////////////////////////////////////////////////
  1478. // terrain definitions
  1479. #define        (kMinIntElevation,                -10)
  1480. #define        (kMaxIntElevation,                12)
  1481. #define        (kElevationScale,                      1)
  1482. #define        (kPercentLand,                    Between(0.5, 0.5))
  1483. #define        (kWaterBorder,                    0)
  1484. #define        (kRiverWidth,                    5)
  1485. #define        (kCoastToDeepWaterPercentage                1.0)
  1486. #define        (kHeightMapChaos,                    Between(10, 15))
  1487.         
  1488. #define        (kMinimumStartPositionToMapEdge        4)
  1489. #define        (kOuterPushFromMapCenter            10)
  1490. #define        (kInnerPushFromMapCenter             0)
  1491.  
  1492. //////////////////////////////////////////////////////////////////////
  1493. // player definitions
  1494. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  1495. #define        (kPlayerInnerRadius,            0.01)
  1496. #define        (kPlayerOuterRadius,            0.9)
  1497. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1498. #define        (kPlayerPercentFlat,            Between(0.75, 0.75))
  1499. #define        (kPlayerLandChaos,            0.8)
  1500. #define        (kPlayerLandClumps,            1)
  1501. #define        (kPlayerFlatChaos,            0.8)
  1502. #define        (kPlayerFlatClumps,            1)
  1503. #define        (kPlayerTreePercentage,            0.06)
  1504.  
  1505.  
  1506. //////////////////////////////////////////////////////////////////////
  1507. // inner neutral definitions
  1508. #define        (kNeutralInnerRadius,            0.05)
  1509. #define        (kNeutralOuterRadius,            0.4)
  1510. #define        (kNeutralOptimalFactor,            0.7)
  1511. #define        (kNumInnerNeutrals,            Between(0, 0))
  1512. #define        (kInnerNeutralPercentLand,        0.11)
  1513. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1514. #define        (kInnerNeutralTreePercentage,          0.05)
  1515. #define        (kInnerNeutralLandChaos,        0.8)
  1516. #define        (kInnerNeutralLandClumps,        2)
  1517. #define        (kInnerNeutralFlatChaos,        0.8)
  1518. #define        (kInnerNeutralFlatClumps,        2)
  1519.  
  1520.  
  1521. //////////////////////////////////////////////////////////////////////
  1522. // outer neutral definitions
  1523. #define        (kNumOuterNeutrals,            Between(0, 0))
  1524. #define        (kOuterNeutralPercentLand,        0.35)
  1525. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1526. #define        (kOuterNeutralTreePercentage,          0.05)
  1527. #define        (kOuterNeutralLandChaos,        0.8)
  1528. #define        (kOuterNeutralLandClumps,        2)
  1529. #define        (kOuterNeutralFlatChaos,        0.8)
  1530. #define        (kOuterNeutralFlatClumps,        2)
  1531.  
  1532.  
  1533. //////////////////////////////////////////////////////////////////////
  1534. // resource definitions
  1535. #define        (kMaxResourceElevation,            2)
  1536. #define        (kResourceToEdgeDistance,        2)
  1537. #define        (kResourceToWaterDistance,        2)
  1538.  
  1539. #define        (kAnimalPerPlayer,            0)
  1540. #define        (kAnimalPerNeutral,            0)
  1541.  
  1542. #define        (kBerryPerPlayer,                0)
  1543. #define        (kBerryPerNeutral,            0)
  1544.  
  1545. #define        (kFishPerPlayer,                7)
  1546. #define        (kFishPerNeutral,                0)
  1547.  
  1548. #define        (kGoldPerPlayer,                2)
  1549. #define        (kGoldPerNeutral,                0)
  1550.  
  1551. #define        (kOilPerPlayer,                0)
  1552. #define        (kOilPerNeutral,                0)
  1553.  
  1554. #define        (kSteelPerPlayer,                2)
  1555. #define        (kSteelPerNeutral,            0)
  1556.  
  1557. #define        (kStonePerPlayer,                1)
  1558. #define        (kStonePerNeutral,            0)
  1559.  
  1560. #define        (kTreePerPlayer,                0)
  1561. #define        (kTreePerNeutral,                0)
  1562.  
  1563. //////////////////////////////////////////////////////////////////////
  1564. // forest definitions
  1565. #define        (kForestFreeRadius,            5.0)
  1566. #define        (kForestsPerPlayer,            2)
  1567. #define        (kForestChaosLevel,            0.1)
  1568. #define        (kMaxClumpsPerForest,            2)
  1569.  
  1570.  
  1571.  
  1572. //////////////////////////////////////////////////////////////////////
  1573. // End of if...elif... command
  1574. #endif
  1575.  
  1576. #endif        // NOTDEFINED(LARGE_ISLANDS_MEDIUM_RMV)
  1577.